const cloud = require('wx-server-sdk');
const rpcUtils = require('../utils/rpcUtils');

// 初始化云开发
cloud.init({
  env: cloud.DYNAMIC_CURRENT_ENV
});

const db = cloud.database();

/**
 * 获取零食铺页面初始化信息
 * @param {Object} request - 请求参数
 * @param {string} request.productId - 产品ID（snacks_store）
 * @param {string} request.schoolCode - 学校代码
 * @returns {Object} 包含楼栋列表和配置信息
 */
async function getSubProductPageInfo(request) {
  try {
    console.log('getSubProductPageInfo 请求参数:', JSON.stringify(request));
    
    const { productId, schoolCode } = request;
    
    // 验证参数
    if (!productId) {
      return rpcUtils.genResp(
        rpcUtils.codeEnum.PARAM_ERROR, 
        'productId参数不能为空', 
        null
      );
    }

    if (!schoolCode) {
      return rpcUtils.genResp(
        rpcUtils.codeEnum.PARAM_ERROR, 
        'schoolCode参数不能为空', 
        null
      );
    }

    // 从数据库获取楼栋列表
    const buildingsResult = await db.collection('snack_school_building')
      .where({
        school_code: schoolCode,
        is_active: true
      })
      .field({
        building_code: true,
        building_name: true,
        notice_banner: true
      })
      .get();

    if (buildingsResult.errMsg === 0) {
      console.error('获取楼栋列表失败:', buildingsResult.errMsg);
      return rpcUtils.genResp(
        rpcUtils.codeEnum.ERROR, 
        '获取楼栋列表失败', 
        null
      );
    }

    const buildings = buildingsResult.data.map(item => ({
      buildingCode: item.building_code,
      buildingName: item.building_name,
      noticeBanner: item.notice_banner || ''
    }));

    // 获取营业时间公告（取第一个楼栋的公告）
    const noticeBannerText = buildingsResult.data.length > 0 
      ? buildingsResult.data[0].notice_banner 
      : '周一至周五 8:00-22:00 | 周末 9:00-21:00';
    
    const responseData = {
      buildings: buildings,
      noticeBannerText: noticeBannerText
    };

    console.log('getSubProductPageInfo 返回数据:', JSON.stringify(responseData));
    
    return rpcUtils.genResp(
      rpcUtils.codeEnum.SUCCESS, 
      'success', 
      responseData
    );
    
  } catch (error) {
    console.error('getSubProductPageInfo Error:', error);
    console.error('Error stack:', error.stack);
    return rpcUtils.genResp(
      rpcUtils.codeEnum.ERROR, 
      `获取页面信息失败: ${error.message}`, 
      null
    );
  }
}

/**
 * 获取指定楼栋的商品列表
 * @param {Object} request - 请求参数
 * @param {string} request.productId - 产品ID（snacks_store）
 * @param {string} request.buildingCode - 楼栋代码
 * @param {string} request.schoolCode - 学校代码
 * @returns {Object} 包含商品列表
 */
async function getSubProductListForBuilding(request) {
  try {
    console.log('getSubProductListForBuilding 请求参数:', JSON.stringify(request));
    
    const { productId, buildingCode, schoolCode } = request;
    
    // 验证参数
    if (!productId) {
      return rpcUtils.genResp(
        rpcUtils.codeEnum.PARAM_ERROR, 
        'productId参数不能为空', 
        null
      );
    }
    
    if (!buildingCode) {
      return rpcUtils.genResp(
        rpcUtils.codeEnum.PARAM_ERROR, 
        'buildingCode参数不能为空', 
        null
      );
    }

    if (!schoolCode) {
      return rpcUtils.genResp(
        rpcUtils.codeEnum.PARAM_ERROR, 
        'schoolCode参数不能为空', 
        null
      );
    }

    // 从数据库查询商品列表
    const productsResult = await db.collection('snack_subproduct')
      .where({
        building_code: buildingCode,
        school_code: schoolCode,
        status: 'ON_SALE'
      })
      .field({
        sub_product_id: true,
        product_name: true,
        price: true,
        stock: true,
        img_list: true,
        building_code: true,
        school_code: true
      })
      .get();

    if (productsResult.errMsg === 0) {
      console.error('获取商品列表失败:', productsResult.errMsg);
      return rpcUtils.genResp(
        rpcUtils.codeEnum.ERROR, 
        '获取商品列表失败', 
        null
      );
    }

    const subProductList = productsResult.data.map(item => ({
      subProductId: item.sub_product_id,
      productName: item.product_name,
      price: item.price,
      stock: item.stock,
      imgList: item.img_list || [],
      buildingCode: item.building_code,
      schoolCode: item.school_code
    }));
    
    const responseData = {
      subProductList: subProductList
    };

    console.log(`getSubProductListForBuilding 返回${subProductList.length}个商品`);
    
    return rpcUtils.genResp(
      rpcUtils.codeEnum.SUCCESS, 
      'success', 
      responseData
    );
    
  } catch (error) {
    console.error('getSubProductListForBuilding Error:', error);
    console.error('Error stack:', error.stack);
    return rpcUtils.genResp(
      rpcUtils.codeEnum.ERROR, 
      `获取商品列表失败: ${error.message}`, 
      null
    );
  }
}


/**
 * 获取指定学校的楼栋列表
 * @param {Object} request - 请求参数
 * @param {string} request.schoolCode - 学校代码
 * @returns {Object} 包含楼栋列表
 */
async function getBuildingListBySchoolAdmin(request) {
  try {
    console.log('getBuildingListBySchoolAdmin 请求参数:', JSON.stringify(request));
    
    const { schoolCode } = request;
    
    // 验证参数
    if (!schoolCode) {
      return rpcUtils.genResp(
        rpcUtils.codeEnum.PARAM_ERROR, 
        'schoolCode参数不能为空', 
        null
      );
    }

    // 从数据库获取楼栋列表
    const buildingsResult = await db.collection('snack_school_building')
      .where({
        school_code: schoolCode,
        is_active: true
      })
      .field({
        building_code: true,
        building_name: true
      })
      .get();

    if (buildingsResult.errMsg === 0) {
      console.error('获取楼栋列表失败:', buildingsResult.errMsg);
      return rpcUtils.genResp(
        rpcUtils.codeEnum.ERROR, 
        '获取楼栋列表失败', 
        null
      );
    }

    const buildingList = buildingsResult.data.map(item => ({
      buildingCode: item.building_code,
      buildingName: item.building_name
    }));
    
    const responseData = {
      buildingList: buildingList
    };

    console.log(`getBuildingListBySchoolAdmin 返回${buildingList.length}个楼栋`);
    
    return rpcUtils.genResp(
      rpcUtils.codeEnum.SUCCESS, 
      'success', 
      responseData
    );
    
  } catch (error) {
    console.error('getBuildingListBySchoolAdmin Error:', error);
    console.error('Error stack:', error.stack);
    return rpcUtils.genResp(
      rpcUtils.codeEnum.ERROR, 
      `获取楼栋列表失败: ${error.message}`, 
      null
    );
  }
}

/**
 * 获取零食商品列表（管理用）
 * @param {Object} request - 请求参数
 * @param {string} request.schoolCode - 学校代码
 * @param {string} request.buildingCode - 楼栋代码
 * @param {string} request.searchKeyword - 搜索关键词（可选）
 * @returns {Object} 包含商品列表
 */
async function getSnacksListForAdmin(request) {
  try {
    console.log('getSnacksListForAdmin 请求参数:', JSON.stringify(request));
    
    const { schoolCode, buildingCode, searchKeyword } = request;
    
    // 验证参数
    if (!schoolCode) {
      return rpcUtils.genResp(
        rpcUtils.codeEnum.PARAM_ERROR, 
        'schoolCode参数不能为空', 
        null
      );
    }

    if (!buildingCode) {
      return rpcUtils.genResp(
        rpcUtils.codeEnum.PARAM_ERROR, 
        'buildingCode参数不能为空', 
        null
      );
    }

    // 构建查询条件
    let whereCondition = {
      school_code: schoolCode,
      building_code: buildingCode
    };

    // 如果有搜索关键词，添加产品名称模糊查询
    if (searchKeyword && searchKeyword.trim()) {
      whereCondition.product_name = db.RegExp({
        regexp: searchKeyword.trim(),
        options: 'i'
      });
    }

    // 从数据库查询商品列表
    const productsResult = await db.collection('snack_subproduct')
      .where(whereCondition)
      .field({
        _id: true,
        sub_product_id: true,
        product_name: true,
        price: true,
        stock: true,
        status: true,
        img_list: true,
        building_code: true,
        school_code: true,
        create_ts: true,
        update_ts: true
      })
      .orderBy('create_ts', 'desc')
      .get();

    if (productsResult.errMsg === 0) {
      console.error('获取商品列表失败:', productsResult.errMsg);
      return rpcUtils.genResp(
        rpcUtils.codeEnum.ERROR, 
        '获取商品列表失败', 
        null
      );
    }

    const snacksList = productsResult.data.map(item => ({
      _id: item._id,
      subProductId: item.sub_product_id,
      productName: item.product_name,
      price: item.price,
      stock: item.stock,
      status: item.status,
      imgList: item.img_list || [],
      buildingCode: item.building_code,
      schoolCode: item.school_code,
      createTs: item.create_ts,
      updateTs: item.update_ts
    }));
    
    const responseData = {
      snacksList: snacksList
    };

    console.log(`getSnacksListForAdmin 返回${snacksList.length}个商品`);
    
    return rpcUtils.genResp(
      rpcUtils.codeEnum.SUCCESS, 
      'success', 
      responseData
    );
    
  } catch (error) {
    console.error('getSnacksListForAdmin Error:', error);
    console.error('Error stack:', error.stack);
    return rpcUtils.genResp(
      rpcUtils.codeEnum.ERROR, 
      `获取商品列表失败: ${error.message}`, 
      null
    );
  }
}

/**
 * 更新零食商品状态
 * @param {Object} request - 请求参数
 * @param {string} request.snackId - 商品ID
 * @param {string} request.status - 状态（ON_SALE/OFF_SALE）
 * @returns {Object} 操作结果
 */
async function updateSnackStatusAdmin(request) {
  try {
    console.log('updateSnackStatusAdmin 请求参数:', JSON.stringify(request));
    
    const { snackId, status } = request;
    
    // 验证参数
    if (!snackId) {
      return rpcUtils.genResp(
        rpcUtils.codeEnum.PARAM_ERROR, 
        'snackId参数不能为空', 
        null
      );
    }

    if (!status || !['ON_SALE', 'OFF_SALE'].includes(status)) {
      return rpcUtils.genResp(
        rpcUtils.codeEnum.PARAM_ERROR, 
        'status参数无效', 
        null
      );
    }

    // 更新商品状态
    const updateResult = await db.collection('snack_subproduct')
      .doc(snackId)
      .update({
        data: {
          status: status,
          update_ts: new Date()
        }
      });

    if (updateResult.errMsg === 0) {
      console.error('更新商品状态失败:', updateResult.errMsg);
      return rpcUtils.genResp(
        rpcUtils.codeEnum.ERROR, 
        '更新商品状态失败', 
        null
      );
    }

    console.log('updateSnackStatusAdmin 成功');
    
    return rpcUtils.genResp(
      rpcUtils.codeEnum.SUCCESS, 
      'success', 
      { updated: true }
    );
    
  } catch (error) {
    console.error('updateSnackStatusAdmin Error:', error);
    console.error('Error stack:', error.stack);
    return rpcUtils.genResp(
      rpcUtils.codeEnum.ERROR, 
      `更新商品状态失败: ${error.message}`, 
      null
    );
  }
}

/**
 * 保存零食商品（新增或编辑）
 * @param {Object} request - 请求参数
 * @param {string} request.snackId - 商品ID（编辑时必填，新增时为空）
 * @param {string} request.schoolCode - 学校代码
 * @param {string} request.buildingCode - 楼栋代码
 * @param {string} request.subProductId - 子产品ID
 * @param {string} request.productName - 产品名称
 * @param {string} request.price - 价格
 * @param {number} request.stock - 库存
 * @param {Array} request.imgList - 图片列表
 * @returns {Object} 操作结果
 */
async function saveSnackAdmin(request) {
  try {
    console.log('saveSnackAdmin 请求参数:', JSON.stringify(request));
    
    const { 
      snackId, 
      schoolCode, 
      buildingCode, 
      subProductId, 
      productName, 
      price, 
      stock, 
      imgList 
    } = request;
    
    // 验证参数
    if (!schoolCode) {
      return rpcUtils.genResp(
        rpcUtils.codeEnum.PARAM_ERROR, 
        'schoolCode参数不能为空', 
        null
      );
    }

    if (!buildingCode) {
      return rpcUtils.genResp(
        rpcUtils.codeEnum.PARAM_ERROR, 
        'buildingCode参数不能为空', 
        null
      );
    }

    if (!subProductId) {
      return rpcUtils.genResp(
        rpcUtils.codeEnum.PARAM_ERROR, 
        'subProductId参数不能为空', 
        null
      );
    }

    if (!productName) {
      return rpcUtils.genResp(
        rpcUtils.codeEnum.PARAM_ERROR, 
        'productName参数不能为空', 
        null
      );
    }

    if (!price) {
      return rpcUtils.genResp(
        rpcUtils.codeEnum.PARAM_ERROR, 
        'price参数不能为空', 
        null
      );
    }

    if (stock === undefined || stock === null) {
      return rpcUtils.genResp(
        rpcUtils.codeEnum.PARAM_ERROR, 
        'stock参数不能为空', 
        null
      );
    }

    const now = new Date();
    const snackData = {
      sub_product_id: subProductId,
      product_name: productName,
      price: price,
      stock: stock,
      img_list: imgList || [],
      building_code: buildingCode,
      school_code: schoolCode,
      status: 'ON_SALE',
      update_ts: now
    };

    let result;
    if (snackId) {
      // 编辑模式
      result = await db.collection('snack_subproduct')
        .doc(snackId)
        .update({
          data: snackData
        });
    } else {
      // 新增模式
      snackData.create_ts = now;
      result = await db.collection('snack_subproduct')
        .add({
          data: snackData
        });
    }

    if (result.errMsg === 0) {
      console.error('保存商品失败:', result.errMsg);
      return rpcUtils.genResp(
        rpcUtils.codeEnum.ERROR, 
        '保存商品失败', 
        null
      );
    }

    console.log('saveSnackAdmin 成功');
    
    return rpcUtils.genResp(
      rpcUtils.codeEnum.SUCCESS, 
      'success', 
      { saved: true, _id: result._id }
    );
    
  } catch (error) {
    console.error('saveSnackAdmin Error:', error);
    console.error('Error stack:', error.stack);
    return rpcUtils.genResp(
      rpcUtils.codeEnum.ERROR, 
      `保存商品失败: ${error.message}`, 
      null
    );
  }
}

/**
 * 获取楼栋配送费信息
 * @param {Object} request - 请求参数
 * @param {string} request.schoolCode - 学校代码
 * @param {string} request.buildingCode - 楼栋代码
 * @returns {Object} 包含配送费信息的响应
 */
async function getBuildingDeliveryFee(request) {
  try {
    console.log('getBuildingDeliveryFee 请求参数:', JSON.stringify(request));
    
    const { schoolCode, buildingCode } = request;
    
    // 验证参数
    if (!schoolCode) {
      return rpcUtils.genResp(
        rpcUtils.codeEnum.PARAM_ERROR, 
        'schoolCode参数不能为空', 
        null
      );
    }

    if (!buildingCode) {
      return rpcUtils.genResp(
        rpcUtils.codeEnum.PARAM_ERROR, 
        'buildingCode参数不能为空', 
        null
      );
    }

    // 从数据库获取楼栋配送费信息
    const buildingResult = await db.collection('snack_school_building')
      .where({
        school_code: schoolCode,
        building_code: buildingCode,
        is_active: true
      })
      .field({
        building_code: true,
        building_name: true,
        delivery_fee: true,
        notice_banner: true
      })
      .get();

    if (buildingResult.data.length === 0) {
      return rpcUtils.genResp(
        rpcUtils.codeEnum.NOT_FOUND, 
        '未找到对应的楼栋信息', 
        null
      );
    }

    const buildingInfo = buildingResult.data[0];
    const deliveryFee = buildingInfo.delivery_fee || 2.0; // 默认配送费2元
    const businessHours = buildingInfo.notice_banner || ''; // 用户须知（存储在notice_banner字段）

    return rpcUtils.genResp(
      rpcUtils.codeEnum.SUCCESS, 
      '获取楼栋设置信息成功', 
      {
        buildingCode: buildingInfo.building_code,
        buildingName: buildingInfo.building_name,
        deliveryFee: deliveryFee,
        businessHours: businessHours,
        noticeBanner: buildingInfo.notice_banner
      }
    );

  } catch (error) {
    console.error('getBuildingDeliveryFee 错误:', error);
    return rpcUtils.genResp(
      rpcUtils.codeEnum.SYSTEM_ERROR, 
      '获取配送费信息失败', 
      null
    );
  }
}

/**
 * 更新楼栋配送费
 * @param {Object} request - 请求参数
 * @param {string} request.schoolCode - 学校代码
 * @param {string} request.buildingCode - 楼栋代码
 * @param {number} request.deliveryFee - 配送费
 * @returns {Object} 更新结果
 */
async function updateBuildingDeliveryFee(request) {
  try {
    console.log('updateBuildingDeliveryFee 请求参数:', JSON.stringify(request));
    
    const { schoolCode, buildingCode, deliveryFee, businessHours } = request;
    
    // 验证参数
    if (!schoolCode) {
      return rpcUtils.genResp(
        rpcUtils.codeEnum.PARAM_ERROR, 
        'schoolCode参数不能为空', 
        null
      );
    }

    if (!buildingCode) {
      return rpcUtils.genResp(
        rpcUtils.codeEnum.PARAM_ERROR, 
        'buildingCode参数不能为空', 
        null
      );
    }

    if (deliveryFee === undefined || deliveryFee === null) {
      return rpcUtils.genResp(
        rpcUtils.codeEnum.PARAM_ERROR, 
        'deliveryFee参数不能为空', 
        null
      );
    }

    if (deliveryFee < 0) {
      return rpcUtils.genResp(
        rpcUtils.codeEnum.PARAM_ERROR, 
        '配送费不能为负数', 
        null
      );
    }

    // 构建更新数据
    const updateData = {
      delivery_fee: deliveryFee,
      update_ts: new Date()
    };
    
    // 如果提供了用户须知，则一起更新
    if (businessHours !== undefined && businessHours !== null) {
      updateData.notice_banner = businessHours;
    }
    
    // 更新楼栋设置
    const updateResult = await db.collection('snack_school_building')
      .where({
        school_code: schoolCode,
        building_code: buildingCode
      })
      .update({
        data: updateData
      });

    if (updateResult.stats.updated === 0) {
      return rpcUtils.genResp(
        rpcUtils.codeEnum.NOT_FOUND, 
        '未找到对应的楼栋信息', 
        null
      );
    }

    return rpcUtils.genResp(
      rpcUtils.codeEnum.SUCCESS, 
      '配送费更新成功', 
      {
        buildingCode: buildingCode,
        deliveryFee: deliveryFee
      }
    );

  } catch (error) {
    console.error('updateBuildingDeliveryFee 错误:', error);
    return rpcUtils.genResp(
      rpcUtils.codeEnum.SYSTEM_ERROR, 
      '更新配送费失败', 
      null
    );
  }
}

/**
 * 获取零食铺订单列表（管理用）
 * @param {Object} request - 请求参数
 * @param {string} request.schoolCode - 学校代码
 * @param {string} request.buildingCode - 楼栋代码
 * @param {string} request.searchKeyword - 搜索关键词（可选）
 * @param {string} request.statusFilter - 状态筛选（可选）
 * @returns {Object} 包含订单列表
 */
async function getSnacksOrdersForAdmin(request) {
  try {
    console.log('getSnacksOrdersForAdmin 请求参数:', JSON.stringify(request));
    
    const { schoolCode, buildingCode, searchKeyword, statusFilter } = request;
    
    // 验证参数
    if (!schoolCode) {
      return rpcUtils.genResp(
        rpcUtils.codeEnum.PARAM_ERROR, 
        'schoolCode参数不能为空', 
        null
      );
    }

    if (!buildingCode) {
      return rpcUtils.genResp(
        rpcUtils.codeEnum.PARAM_ERROR, 
        'buildingCode参数不能为空', 
        null
      );
    }

    // 构建查询条件
    let whereCondition = {
      'order_item.product_id': 'PSnackPickup', // 零食铺订单
      'address.schoolCode': schoolCode,
      'delivery_address.building_code': buildingCode,
      // 全部列表中需要包含已支付/退款中/部分退款/已退款
      order_status: db.command.in(['已支付', '退款中', '部分退款', '已退款'])
    };

    // 添加状态筛选
    if (statusFilter && statusFilter !== 'all') {
      switch (statusFilter) {
        case 'pending':
          whereCondition.process_status = '待配送';
          // 待配送状态排除已退款的订单
          whereCondition.order_status = db.command.in(['已支付', '退款中', '部分退款']);
          break;
        case 'delivering':
          whereCondition.process_status = '配送中';
          // 配送中状态排除已退款的订单
          whereCondition.order_status = db.command.in(['已支付', '退款中', '部分退款']);
          break;
        case 'completed':
          whereCondition.process_status = '已完成';
          break;
      }
    }

    // 添加搜索条件
    if (searchKeyword && searchKeyword.trim()) {
      whereCondition.order_id = db.RegExp({
        regexp: searchKeyword.trim(),
        options: 'i'
      });
    }

    // 从数据库查询订单列表
    const ordersResult = await db.collection('order')
      .where(whereCondition)
      .field({
        order_id: true,
        process_status: true,
        order_status: true,
        refund_reason: true,
        create_ts: true,
        address: true,
        delivery_address: true,
        snacks_items: true,
        total_amount: true,
        delivery_fee: true,
        pay_amount: true
      })
      .orderBy('create_ts', 'desc')
      .get();

    if (ordersResult.errMsg === 0) {
      console.error('获取订单列表失败:', ordersResult.errMsg);
      return rpcUtils.genResp(
        rpcUtils.codeEnum.ERROR, 
        '获取订单列表失败', 
        null
      );
    }

    const ordersList = ordersResult.data.map(item => {
      // 格式化时间（明确指定为北京时间 UTC+8）
      const createTime = new Date(item.create_ts).toLocaleString('zh-CN', {
        year: 'numeric',
        month: '2-digit',
        day: '2-digit',
        hour: '2-digit',
        minute: '2-digit',
        timeZone: 'Asia/Shanghai'
      });

      return {
        orderId: item.order_id,
        processStatus: item.process_status,
        orderStatus: item.order_status,
        refundReason: item.refund_reason || '',
        createTime: createTime,
        address: item.address,
        deliveryAddress: item.delivery_address,
        orderItems: item.snacks_items || [], // 使用 snacks_items 字段
        totalPrice: item.total_amount,
        deliveryFee: item.delivery_fee,
        finalPrice: item.pay_amount
      };
    });
    
    const responseData = {
      ordersList: ordersList
    };

    console.log(`getSnacksOrdersForAdmin 返回${ordersList.length}个订单`);
    
    return rpcUtils.genResp(
      rpcUtils.codeEnum.SUCCESS, 
      'success', 
      responseData
    );
    
  } catch (error) {
    console.error('getSnacksOrdersForAdmin Error:', error);
    console.error('Error stack:', error.stack);
    return rpcUtils.genResp(
      rpcUtils.codeEnum.ERROR, 
      `获取订单列表失败: ${error.message}`, 
      null
    );
  }
}

/**
 * 更新零食铺订单状态
 * @param {Object} request - 请求参数
 * @param {string} request.orderId - 订单ID
 * @param {string} request.processStatus - 处理状态
 * @returns {Object} 操作结果
 */
async function updateSnacksOrderStatus(request) {
  try {
    console.log('updateSnacksOrderStatus 请求参数:', JSON.stringify(request));
    
    const { orderId, processStatus } = request;
    
    // 验证参数
    if (!orderId) {
      return rpcUtils.genResp(
        rpcUtils.codeEnum.PARAM_ERROR, 
        'orderId参数不能为空', 
        null
      );
    }

    if (!processStatus) {
      return rpcUtils.genResp(
        rpcUtils.codeEnum.PARAM_ERROR, 
        'processStatus参数不能为空', 
        null
      );
    }

    // 验证状态值
    const validStatuses = ['待配送', '配送中', '已完成'];
    if (!validStatuses.includes(processStatus)) {
      return rpcUtils.genResp(
        rpcUtils.codeEnum.PARAM_ERROR, 
        'processStatus参数无效', 
        null
      );
    }

    // 获取当前用户信息
    const { OPENID: currentUserId } = cloud.getWXContext();
    
    // 构建更新数据
    const updateData = {
      process_status: processStatus,
      update_ts: new Date()
    };

    // 如果状态变为"配送中"，需要填充配送员信息
    if (processStatus === '配送中') {
      // 获取当前用户信息
      const userResult = await db.collection('user').where({
        out_user_id: currentUserId
      }).get();

      if (userResult.data.length > 0) {
        const userInfo = userResult.data[0];
        updateData.deliver_out_user_id = currentUserId;
        updateData.deliver_user_phone = userInfo.phone || '';
        console.log('填充配送员信息:', {
          deliver_out_user_id: currentUserId,
          deliver_user_phone: userInfo.phone
        });
      } else {
        console.warn('未找到当前用户信息，无法填充配送员信息');
        // 即使没有用户信息，也继续更新状态，但记录警告
        updateData.deliver_out_user_id = currentUserId;
        updateData.deliver_user_phone = '';
      }
    }

    // 更新订单状态
    const updateResult = await db.collection('order')
      .where({
        order_id: orderId,
        'order_item.product_id': 'PSnackPickup' // 确保是零食铺订单
      })
      .update({
        data: updateData
      });

    if (updateResult.stats.updated === 0) {
      return rpcUtils.genResp(
        rpcUtils.codeEnum.NOT_FOUND, 
        '订单不存在或状态更新失败', 
        null
      );
    }

    console.log('updateSnacksOrderStatus 成功');
    
    return rpcUtils.genResp(
      rpcUtils.codeEnum.SUCCESS, 
      'success', 
      { updated: true }
    );
    
  } catch (error) {
    console.error('updateSnacksOrderStatus Error:', error);
    console.error('Error stack:', error.stack);
    return rpcUtils.genResp(
      rpcUtils.codeEnum.ERROR, 
      `更新订单状态失败: ${error.message}`, 
      null
    );
  }
}

module.exports = {
  getSubProductPageInfo,
  getSubProductListForBuilding,
  getBuildingListBySchoolAdmin,
  getSnacksListForAdmin,
  updateSnackStatusAdmin,
  saveSnackAdmin,
  getBuildingDeliveryFee,
  updateBuildingDeliveryFee,
  getSnacksOrdersForAdmin,
  updateSnacksOrderStatus
};

